# crud/sys_user.py
from pydoc import pager

from sqlalchemy.orm import Session
from src.models import sys_user as models
from src.schemas import sys_user as schemas, request_model
from src.core import retMes, str_utils as strU, orm_curd
from src.schemas.login_manager import AuthManager


def create_user(db: Session,
                auth: AuthManager,
                user: schemas.SysUserCreate):
    """
       新增单个用户。

       参数说明
       ----------
       db : Session
           数据库会话对象。
       auth:        登录信息
       user : schemas.SysUserCreate
           待创建用户的 Pydantic 模型实例。

       返回值
       -------
       dict
            按 retMes.Success 包装好的 dict
       备注
       ----
       内部调用 create_users 实现单条批量插入，行为与批量接口保持一致。
       """
    # 检查用户是否已存在（基于login_id）
    return orm_curd.Insert(db,
                           auth,
                           models.SysUser,
                           schemas.SysUser,
                           "用户",
                           [user.dict()],  # [u.dict() for u in users],   # users,
                           ["api_id", "login_id"],
                           skip_duplicates=True)


def create_users(db: Session,
                 auth: AuthManager,
                 users: list[schemas.SysUserCreate]):
    """
        批量新增用户。

        参数说明
        ----------
        db : Session
            数据库会话对象。
        auth:        登录信息
        users : list[schemas.SysUserCreate]
            待创建用户的 Pydantic 模型实例列表。

        返回值
        -------
       dict
            按 retMes.Success 包装好的 dict
        """
    return orm_curd.Insert(db,
                           auth,
                           models.SysUser,
                           schemas.SysUser,
                           "用户",
                           users,  #[u.dict() for u in users],   # users,
                           ["api_id", "login_id"],
                           skip_duplicates=True)


def get_users(db: Session,
              auth: AuthManager,
              page: int = 0,
              page_size: int = 100,
              FilterModel: request_model.QueryModel = None,
              id: str = None):
    """
        分页查询系统用户列表。

        参数说明
        ----------
        db : Session
            数据库会话对象，用于执行 ORM 操作。
        auth:        登录信息
        authManager:authManager
            登录信息
        page : int, 可选
            页码，从 0 开始计数；默认值为 0。
        page_size : int, 可选
            每页返回的记录数；默认值为 100。
        FilterModel : request_model.QueryModel, 可选
            查询条件模型，用于构造过滤条件；默认值为 None，表示不过滤。
        id : str, 可选
            用户 ID 精准匹配；默认值为 None，表示不根据 ID 过滤。

        返回值
        -------
        dict
            按 retMes.Success 包装好的 dict

        备注说明
        --------
        1. 本函数通过 `orm_curd.query_with_page` 统一封装，自动完成分页、过滤、排序等操作。
        2. 当 `id` 参数非空时，会优先使用精准匹配；其余过滤条件以 `FilterModel` 为准。
        3. 若 `schemas.SysUser` 为 None，则返回原始 ORM 对象，跳过 Pydantic 校验，性能略高。
        4. 调用方需确保传入的 `db` 处于活跃事务中，避免 Lazy Load 异常。
        """

    return orm_curd.query_with_page(db,
                                    auth,
                                    models.SysUser,
                                    schemas.SysUser,  # 如不需要字段校验可传 None
                                    id=id,
                                    filter_model=FilterModel,
                                    page=page,
                                    page_size=page_size)


def update_user(db: Session,
                auth: AuthManager,
                user_id: str,
                user: schemas.SysUser,
                ) -> schemas.SysUser:
    """
       更新单个用户

       参数
       ----
       db      : SQLAlchemy Session
       auth:        登录信息
       user_id : 待更新用户的主键 id
       user    : Pydantic 模型，仅包含需要修改的字段（exclude_unset=True）

       返回
       ----
       更新后的用户 ORM 对象（已 flush，含最新值）
       """
    update_model = request_model.UpdateModel([
        request_model.UpdateItem(
            pk_names=["id"],
            pk_values=[user_id],
            data=user.dict(exclude_unset=True)
        )
    ])
    return orm_curd.update(db,
                           auth,
                           models.SysUser,
                           update_model)


def update_users(db: Session,
                 auth: AuthManager,
                 updateModel: request_model.UpdateModel
                 ):
    """
    批量更新用户

    参数
    ----
    db          : SQLAlchemy Session
    auth:        登录信息
    updateModel : request_model.UpdateModel
        待更新的用户列表，包含主键 id 和数据字段

    返回
    ----
    按 retMes.Success 封装的 dict
    """
    return orm_curd.update(db,
                           auth,
                           models.SysUser,
                           updateModel)


def delete_user(db: Session,
                auth: AuthManager,
                deleteModel: request_model.DeleteModel):
    """
    调用通用 delete 接口删除指定用户（硬删除）

    :param db:      SQLAlchemy 会话
    :param auth:        登录信息
    :param deleteModel: 删除内容
    :return:        统一响应格式
    """

    # 直接调用通用删除函数
    return orm_curd.delete(db=db,
                           auth=auth,
                           model_cls=models.SysUser,
                           delete_obj=deleteModel)


